home *** CD-ROM | disk | FTP | other *** search
/ A.C.E. 2 / ACE CD 2.iso / FILES / UTILS / GAMESDS3.DMS / GAMESDS3.adf / GDS_Examples.lha / Examples / complex / left_right.c < prev    next >
C/C++ Source or Header  |  1994-11-14  |  11KB  |  378 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <fcntl.h>
  4. #include <string.h>
  5.  
  6. #include <exec/memory.h>
  7. #include <exec/types.h>
  8. #include <graphics/gfxbase.h>
  9.  
  10. #include <clib/exec_protos.h>
  11. #include <clib/graphics_protos.h>
  12.  
  13. #include "GameSmith:include/libraries/libraries.h"
  14. #include "GameSmith:include/libraries/libptrs.h"
  15. #include "GameSmith:GameSmith.h"
  16.  
  17. /*-------------------------------------------------------------------------*/
  18. /* Function Prototypes                                                      */
  19.  
  20. void parser(int,char **);
  21. int setup(void);
  22. void move_image(void);
  23. void check_bounds(void);
  24. int check_close(void);
  25. void cleanup(void);
  26. void free_arrays(void);
  27.  
  28. /*-------------------------------------------------------------------------*/
  29.  
  30. int cplx_cnt,swidth=320,sheight=200,smode=0,delay=0;
  31. int *x=NULL,*y=NULL,*speedx=NULL,*speedy=NULL,*bounce=NULL;
  32. char *file;
  33. int dlist;               /* display list for anims */
  34.  
  35. struct BitMap *bm3=NULL;
  36.  
  37. struct anim_cplx *cplx;
  38.  
  39. struct display_struct *display;
  40.  
  41. /*-------------------------------------------------------------------------*/
  42.  
  43. main(argc,argv)
  44. int argc;
  45. char *argv[];
  46.  
  47. {
  48.    int err,end=0;
  49.  
  50.    if (argc < 3)
  51.       {
  52.       printf("\nUSAGE: left_right {filename} [number of objects] ([HIRES] | [LACE]) [VB delay]\n");
  53.       exit(01);
  54.       }
  55.    if (gs_open_libs(DOS|GRAPHICS,0))
  56.       exit(02);               /* if can't open libs, abort */
  57.    parser(argc,argv);         /* parse command line args */
  58.    if (err=setup())            /* if couldn't get set up... abort program */
  59.       {
  60.       printf("\nsetup error %d\n",err);
  61.       gs_close_libs();         /* close all libraries */
  62.       exit(03);
  63.       }
  64.    Forbid();
  65.    while (!end)
  66.       {
  67.       move_image();
  68.       end=check_close();      /* end when user hits left mouse */
  69.       }
  70.    Permit();
  71.    cleanup();                  /* close & deallocate everything */
  72.    gs_close_libs();            /* close all libraries */
  73. }
  74.  
  75. /***************************************************************************/
  76.  
  77. void parser(argc,argv)
  78. int argc;
  79. char *argv[];
  80.  
  81. {
  82.    file=argv[1];               /* remember file name */
  83.    cplx_cnt=atoi(argv[2]);      /* number of complexes running around screen */
  84.    if (argc >= 4)
  85.       {
  86.       if (!(stricmp(argv[3],"HIRES")))   /* check for hires spec */
  87.          {
  88.          swidth=640;
  89.          sheight=400;
  90.          if (GfxBase->LibNode.lib_Version >= 36)
  91.             {
  92.             if (ModeNotAvailable(DBLNTSCHIRESFF_KEY))
  93.                smode=HIRES|LACE;
  94.             else
  95.                smode=DBLNTSCHIRESFF_KEY;
  96.             }
  97.          else
  98.             smode=HIRES|LACE;
  99.          }
  100.       else if (!(stricmp(argv[3],"SUPER")))   /* check for superhires */
  101.          {
  102.          if (GfxBase->LibNode.lib_Version >= 36)
  103.             {
  104.             if (ModeNotAvailable(SUPER72_MONITOR_ID | SUPERLACE_KEY))
  105.                {
  106.                swidth=640;
  107.                sheight=400;
  108.                smode=HIRES|LACE;
  109.                }
  110.             else
  111.                {
  112.                smode=SUPER72_MONITOR_ID | SUPERLACE_KEY;
  113.                swidth=800;
  114.                sheight=600;
  115.                }
  116.             }
  117.          else
  118.             {
  119.             swidth=640;
  120.             sheight=400;
  121.             smode=HIRES|LACE;
  122.             }
  123.          }
  124.       else if (!(stricmp(argv[3],"HAM")))   /* check for HAM mode */
  125.          {
  126.          smode|=HAM_KEY;
  127.          }
  128.       }
  129.    if (argc >= 5)
  130.       {
  131.       if (!(stricmp(argv[4],"HAM")))      /* check for HAM mode */
  132.          {
  133.          smode|=HAM_KEY;
  134.          }
  135.       else
  136.          {
  137.          delay=atoi(argv[4]);   /* number vertical blank delay intervals between anim updates */
  138.          }
  139.       }
  140. }
  141.  
  142. /***************************************************************************/
  143.  
  144. setup()
  145.  
  146. {
  147.    int cnt,seq,depth=0;
  148.    struct anim_struct *anim;
  149.    struct blit_struct *img;
  150.  
  151.    struct anim_load_struct load =
  152.       {
  153.       NULL,                           /* name of anim file to load */
  154.       NULL,                           /* ptr to anim upon return */
  155.       NULL,                           /* ptr to attachment array specification upon return */
  156.       NULL,                           /* ptr to color map upon return */
  157.       0,                              /* # entries in the color map */
  158.       8,                              /* # bits per color map entry */
  159.       0,                              /* type (filled). 0 = anim, 1 = complex */
  160.       1,                              /* # objects to allocate in array */
  161.       0                              /* flags */
  162.       };
  163.  
  164.    if (!(x=(int *)malloc(cplx_cnt*sizeof(int))))
  165.       return(-1);
  166.    if (!(y=(int *)malloc(cplx_cnt*sizeof(int))))
  167.       {
  168.       free_arrays();
  169.       return(-1);
  170.       }
  171.    if (!(speedx=(int *)malloc(cplx_cnt*sizeof(int))))
  172.       {
  173.       free_arrays();
  174.       return(-1);
  175.       }
  176.    if (!(speedy=(int *)malloc(cplx_cnt*sizeof(int))))
  177.       {
  178.       free_arrays();
  179.       return(-1);
  180.       }
  181.    if (!(bounce=(int *)malloc(cplx_cnt*sizeof(int))))
  182.       {
  183.       free_arrays();
  184.       return(-1);
  185.       }
  186.    for (cnt=0; cnt < cplx_cnt; cnt++)
  187.       bounce[cnt]=0;
  188.    load.filename=file;               /* user specified anim file name */
  189.    load.array_elements=cplx_cnt;      /* user specified # elves */
  190.    if (gs_load_anim(&load))
  191.       {
  192.       free_arrays();
  193.       return(-1);
  194.       }
  195.    cplx=load.anim_ptr.cplx;         /* ptr to anim complex */
  196.    if (load.type != 1)               /* make sure it's an anim complex */
  197.       {
  198.       free_arrays();
  199.       if (load.type == 0)
  200.          gs_free_anim((struct anim_struct *)cplx,cplx_cnt);
  201.       return(-2);
  202.       }
  203.    anim = cplx[0].list;               /* ptr to 1st anim in complex */
  204.    while (anim)
  205.       {
  206.       img = anim->list;               /* ptr to 1st image in anim sequence */
  207.       while (img)                     /* find max depth of anim */
  208.          {
  209.          if (img->depth > depth)
  210.             depth = img->depth;
  211.          if (img->next == img)      /* avoid infinite loop */
  212.             img=NULL;
  213.          else
  214.             img=img->next;
  215.          }
  216.       anim=anim->cplx_next;         /* next anim in complex */
  217.       }
  218.    if (!(display=gs_display(swidth,sheight,depth,smode,GSV_DOUBLE,load.cmap)))
  219.       {
  220.       free_arrays();
  221.       FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  222.       gs_free_cplx(cplx,cplx_cnt);
  223.       return(-3);
  224.       }
  225.    FreeMem(load.cmap,load.cmap_entries*sizeof(long));
  226.    if ((dlist=gs_get_display_list()) < 0)
  227.       {
  228.       cleanup();
  229.       return(-4);
  230.       }
  231.    bm3=gs_get_bitmap(depth,swidth,sheight,0);
  232.    gs_init_anim(dlist,display->vp->bitmap1,display->vp->bitmap2,bm3);
  233.    gs_set_anim_bounds(dlist,0,0,swidth-1,sheight-1);
  234.    for (cnt=0; cnt < cplx_cnt; cnt++)
  235.       {
  236.       x[cnt] = gs_random(swidth);         /* random X,Y coords */
  237.       y[cnt] = gs_random(sheight);
  238.       while ((speedx[cnt] = gs_random(11)) < 3);
  239.       while ((speedy[cnt] = gs_random(4)) == 0);
  240.       if (cnt&1)
  241.          {
  242.          speedx[cnt]=-speedx[cnt];
  243.          speedy[cnt]=-speedy[cnt];
  244.          seq=0;                     /* left moving anim */
  245.          }
  246.       else
  247.          seq=1;                     /* right moving anim */
  248.       if (bm3)                        /* if restore bitmap */
  249.          {
  250.          anim=cplx[cnt].list;         /* ptr to 1st anim object in complex */
  251.          while (anim)
  252.             {
  253.             anim->flags|=ANIM_SAVE_BG;   /* use fastest display method */
  254.             if (anim->flags & ANIM_CLEAR)
  255.                anim->flags ^= ANIM_CLEAR;
  256.             if (anim->flags & ANIM_COPY)
  257.                anim->flags ^= ANIM_COPY;
  258.             anim=anim->cplx_next;   /* next anim object in complex */
  259.             }
  260.          }
  261.       if (gs_add_anim_cplx(dlist,&cplx[cnt],x[cnt],y[cnt],seq,cplx[cnt].list->prio))
  262.          {
  263.          cleanup();                  /* release everything */
  264.          return(-5);                  /* return failure */
  265.          }
  266.       }
  267.    gs_draw_anims(dlist);
  268.    check_bounds();
  269.    gs_next_anim_page(dlist);
  270.    gs_show_display(display,1);
  271.    gs_flip_display(display,1);
  272.    gs_open_vb_timer();
  273.    return(0);
  274. }
  275.  
  276. /***************************************************************************/
  277.  
  278. void move_image()
  279.  
  280. /* move and animate the graphic objects on the screen */
  281.  
  282. {
  283.    int cnt;
  284.  
  285.    if (gs_vb_time() < delay)
  286.       return;
  287.    gs_vb_timer_reset();
  288.    for (cnt=0; cnt < cplx_cnt; cnt++)
  289.       {
  290.       x[cnt]+=speedx[cnt];
  291.       y[cnt]+=speedy[cnt];
  292.       gs_anim_cplx(&cplx[cnt],x[cnt],y[cnt]);
  293.       }
  294.    while (display->flags & GSV_FLIP);   /* while display not flipped */
  295.    gs_draw_anims(dlist);               /* draw them anim objects! */
  296.    check_bounds();                  /* keep a watch on them pesky keeblers */
  297.    gs_next_anim_page(dlist);         /* tell anim sys to use other bitmap */
  298.    gs_flip_display(display,1);      /* switch to other display, sync */
  299. }
  300.  
  301. /***************************************************************************/
  302.  
  303. void check_bounds()
  304.  
  305. {
  306.    int cnt;
  307.  
  308.    for (cnt=0; cnt < cplx_cnt; cnt++)
  309.       {
  310.       if (cplx[cnt].anim->flags & ANIM_BOUNDS_X1)
  311.          {
  312.          x[cnt]=cplx[cnt].anim->x;
  313.          speedx[cnt]=-speedx[cnt];
  314.          gs_set_cplx_seq(&cplx[cnt],1,x[cnt],y[cnt]);   /* move right */
  315.          }
  316.       else if (cplx[cnt].anim->flags & ANIM_BOUNDS_X2)
  317.          {
  318.          x[cnt]=cplx[cnt].anim->x;
  319.          speedx[cnt]=-speedx[cnt];
  320.          gs_set_cplx_seq(&cplx[cnt],0,x[cnt],y[cnt]);   /* move left */
  321.          }
  322.       if ((cplx[cnt].anim->flags & (ANIM_BOUNDS_Y1|ANIM_BOUNDS_Y2)) && (!(bounce[cnt])))
  323.          {
  324.          y[cnt]=cplx[cnt].anim->y;
  325.          speedy[cnt]=-speedy[cnt];
  326.          bounce[cnt]=1;               /* don't get "stuck" on top or bottom */
  327.          }
  328.       else
  329.          bounce[cnt]=0;
  330.       }
  331. }
  332.  
  333. /***************************************************************************/
  334.  
  335. int check_close()
  336.  
  337. /* check for user input */
  338.  
  339. {
  340.    if (gs_joystick(0) & (JOY_BUTTON1|JOY_BUTTON2))   /* IF (mouse button pressed) */
  341.       return(1);                     /* ..time to wrap up */
  342.    return(0);                        /* ELSE (keep going) */
  343. }
  344.  
  345. /***************************************************************************/
  346.  
  347. void cleanup()
  348.  
  349. /* release all resources and memory */
  350.  
  351. {
  352.    if (dlist > -1)
  353.       gs_free_display_list(dlist);
  354.    free_arrays();
  355.    gs_free_cplx(cplx,cplx_cnt);
  356.    gs_remove_display(display);
  357.    gs_close_vb_timer();
  358. }
  359.  
  360. /***************************************************************************/
  361.  
  362. void free_arrays()
  363.  
  364. {
  365.    if (bounce)
  366.       free(bounce);
  367.    if (speedy)
  368.       free(speedy);
  369.    if (speedx)
  370.       free(speedx);
  371.    if (y)
  372.       free(y);
  373.    if (x)
  374.       free(x);                     /* free up control arrays */
  375.    if (bm3)
  376.       gs_free_bitmap(bm3);
  377. }
  378.